﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Generic.Contract;
using Generic.Business.Manager;
using Generic.Business.Validation;
using System.Transactions;

namespace Generic.Business.Process
{
    public abstract class BPGeneric<BE, BM, BV, FE> : BusinessProcess<BE, FE, BM, BV>
        where BE : BusinessEntity, new()
        where BM : class, IBusinessManager<BE, FE>, IBMGeneric<BE, FE>, new()
        where BV : BVGeneric<BE, FE>, new()
        where FE : FilterEntity
    {
        public BPGeneric()
            : base()
        {
        }

        public virtual BE Copiar(BE entidade)
        {
            try
            {
                return this.BusinessManager.Copiar(entidade);
            }
            catch (Exception ex) { throw ex; }
        }

        public virtual List<BE> ObterTodos(FE filtro)
        {
            try
            {
                return this.BusinessManager.ObterTodos(filtro);
            }
            catch (Exception ex) { throw ex; }
        }

        public virtual BE ObterEntidade(int codigo)
        {
            return this.BusinessManager.ObterEntidade(codigo);
        }

        public virtual void Excluir(BE entidade)
        {
            try
            {
                using (TransactionScope ts = new TransactionScope(TransactionScopeOption.Required))
                {
                    this.BusinessManager.Excluir(entidade);
                    ts.Complete();
                }
            }
            catch (Exception ex) { throw ex; }
        }

        public virtual BE Salvar(BE entidade)
        {
            try
            {
                this.BusinessValidation.ValidarCampos(entidade);
                this.BusinessValidation.ThrowBusinessValidationError();

                using (TransactionScope ts = new TransactionScope(TransactionScopeOption.Required))
                {
                    this.BusinessManager.Salvar(entidade);
                    ts.Complete();
                }

                return entidade;
            }
            catch (Exception ex) { throw ex; }
        }

        public virtual void ExcluirLista(List<BE> entidades)
        {
            try
            {
                this.BusinessManager.Excluir(entidades);
            }
            catch (Exception ex) { throw ex; }
        }

        public virtual List<BE> SalvarLista(List<BE> entidades)
        {
            try
            {
                List<BE> novasEntidades = new List<BE>();

                novasEntidades = this.BusinessManager.Salvar(entidades);

                return novasEntidades;
            }
            catch (Exception ex) { throw ex; }
        }
    }
}
